//科学计数法转小数

export const scientificToNumber = function (val) {
    console.log(val)
    const e = String(val)
    var len,
        zero = '';
    let rex = /^([0-9])\.?([0-9]*)e-([0-9]*)/
    if (!rex.test(e)) return val
    const numArr = e.match(rex)
    console.log(numArr)
    const n = Number('' + numArr[1] + (numArr[2] || ''))
    len = Math.abs(numArr[3]) - 1;
    console.log(len)
    for (var i = 0; i < len; i++) {
        zero += '0';
    }
    console.log(zero)
    // console.log(n)
    // console.log(String(Math.pow(10, Number(numArr[3]) - 1)).substr(1))
    const num = '0.' + zero + n
    return num // 防止可能出现0.0001540000000的情况





    // console.log(num)
    // var str = num.toString();
    // var reg = /^(\d+)(e)([\-]?\d+)$/;
    // // var reg =/^([0-9])\.?([0-9]*)e-([0-9])/

    // // var reg = /^([0-9])\.?([0-9]*)e([\-]?\d+)$/;
    // // // var reg =/^([0-9])\.?([0-9]*)e-([0-9])/
    // var arr, len,
    //     zero = '';

    // /*6e7或6e+7 都会自动转换数值*/
    // if (!reg.test(str)) {
    // 	return num;
    // } else {
    // 	/*6e-7 需要手动转换*/
    //     arr = reg.exec(str);
    //     console.log(arr)
    // 	len = Math.abs(arr[3]) - 1;
    // 	for (var i = 0; i < len; i++) {
    // 		zero += '0';
    // 	}
    // 	return '0.' + zero + arr[1];
    // }
}




export const dome = function (min, max) {
    const value = (rule, value, callback) => {

        if (value === "") {
            callback(new Error("输入值不能为空"))
        } else if (parseFloat(value) < min || value > max) {
            callback(new Error("输入范围为[" + min + "，" + max + "]"))
        } else {
            callback()
        }
    }
    return value
}


export const optional = function (min, max) {
    const value = (rule, value, callback) => {
        if (value == '') {
            callback()
        } else {
            if (parseFloat(value) < min || value > max) {
                callback(new Error("输入范围为[" + min + "，" + max + "]"))
            } else {
                callback()
            }
        }

    }
    return value
}



export const sortverify = function (min, max, length) {
    const M4RNDSTS001 = (rule, value, callback) => {

        let tempdata = value.trim().split(/\s+/)

        if (parseFloat(tempdata[tempdata.length - 1]).toString() == "NaN") {
            callback(new Error("请输入正确的格式"))
        } else if (
            tempdata[tempdata.length - 1] < min ||
            tempdata[tempdata.length - 1] > max
        ) {
            callback(new Error("输入范围为[" + min + "，" + max + "]"))
        } else if (
            tempdata.length >= 1 &&
            tempdata[tempdata.length - 1] < tempdata[tempdata.length - 2]
        ) {
            callback(
                new Error("多个距离输入请按照从小到大输入，以空隔分开")
            )
        } else if (tempdata.length > length) {
            callback(
                new Error("输入距离个数应小于" + length)
            )
        } else {
            callback()
        }
    }

    return M4RNDSTS001
}



export const selecttext = (rule, value, callback) => {
    if (value == "") {
        callback(new Error("输入值不能为空"))
    } else {
        callback()
    }
    
}

export const text = function (min, max) {
    const value = (rule, value, callback) => {

        if (value == "") {
            callback(new Error("输入值不能为空"))
        } else if (value.length < min || value.length > max) {
            callback(new Error("输入字数为[" + min + "，" + max + "]"))
        } else {
            callback()
        }
    }
    return value
}


export const v6086400 = (rule, value, callback) => {
    if (value == "") {
        callback(new Error("输入值不能为空"))
    } else if (value < 60.0 || value > 86400.0) {
        callback(new Error("输入范围为[60.0，86400]"))
    } else {
        callback()
    }
}

export const v00604800 = (rule, value, callback) => {
    if (value == "") {
        callback(new Error("输入值不能为空"))
    } else if (value < 0.0 || value > 604800.0) {
        callback(new Error("输入范围为[0.0，604800.0]"))
    } else {
        callback()
    }
}


export const v27101012 = (rule, value, callback) => {
    if (value == "") {
        callback(new Error("输入值不能为空"))
    } else if (value < 2.7e-10 || value > 1.0e12) {
        callback(new Error("输入范围为[2.7E-10，1.0E+12]"))
    } else {
        callback()
    }
}






export const v08 = (rule, value, callback) => {
    if (value == "") {
        callback(new Error("输入值不能为空"))
    } else if (value < 0.0 || value > 8.0) {
        callback(new Error("输入范围为[0，8]"))
    } else {
        callback()
    }
}


export const v0010 = (rule, value, callback) => {
    if (value == "") {
        callback(new Error("输入值不能为空"))
    } else if (value < 0.0 || value > 1.0) {
        callback(new Error("输入范围为[0.0，1.0]"))
    } else {
        callback()
    }
}

export const v0011000 = (rule, value, callback) => {
    if (value == "") {
        callback(new Error("输入值不能为空"))
    } else if (value < 0.01 || value > 100.0) {
        callback(new Error("输入范围为[0.01，100.0]"))
    } else {
        callback()
    }
}

export const v0011001 = (rule, value, callback) => {
    if (value == "") {
        callback(new Error("输入值不能为空"))
    } else if (value < 0.01 || value > 100.1) {
        callback(new Error("输入范围为[0.01，100.1]"))
    } else {
        callback()
    }
}


export const v00110 = (rule, value, callback) => {
    if (value == "") {
        callback(new Error("输入值不能为空"))
    } else if (value < 0.01 || value > 1.0) {
        callback(new Error("输入范围为[0.01，1.0]"))
    } else {
        callback()
    }
}

export const v0035 = (rule, value, callback) => {
    if (value == "") {
        callback(new Error("输入值不能为空"))
    } else if (value < 0.0 || value > 35) {
        callback(new Error("输入范围为[0.0，35]"))
    } else {
        callback()
    }
}
export const v10E610 = (rule, value, callback) => {
    if (value == "") {
        callback(new Error("输入值不能为空"))
    } else if (value < 1.0E-6 || value > 10) {
        callback(new Error("输入范围为[1.0E-6，10]"))
    } else {
        callback()
    }
}

export const v10E210E4 = (rule, value, callback) => {
    if (value == "") {
        callback(new Error("输入值不能为空"))
    } else if (value < 1.0E+2 || value > 1.0E+4) {
        callback(new Error("输入范围为[1.0E+2，1.0E+4]"))
    } else {
        callback()
    }
}

export const v16 = (rule, value, callback) => {
    if (value == "") {
        callback(new Error("输入值不能为空"))
    } else if (value < 1 || value > 6) {
        callback(new Error("输入范围为[1，6]"))
    } else {
        callback()
    }
}

export const v00990 = (rule, value, callback) => {
    if (value == "") {
        callback(new Error("输入值不能为空"))
    } else if (value < 0.0 || value > 99.0) {
        callback(new Error("输入范围为[0.0，99.0]"))
    } else {
        callback()
    }
}

export const v05300 = (rule, value, callback) => {
    if (value == "") {
        callback(new Error("输入值不能为空"))
    } else if (value < 0.5 || value > 30.0) {
        callback(new Error("输入范围为[0.5，30.0]"))
    } else {
        callback()
    }
}


export const v000110E6 = (rule, value, callback) => {
    if (value == "") {
        callback(new Error("输入值不能为空"))
    } else if (value < 0.001 || value > 1.0E+6) {
        callback(new Error("输入范围为[0.001，1.0E+6]"))
    } else {
        callback()
    }
}

export const v001020 = (rule, value, callback) => {
    if (value == "") {
        callback(new Error("输入值不能为空"))
    } else if (value < 0.0 || value > 1.0e20) {
        callback(new Error("输入范围为[0.0，1.0E+20]"))
    } else {
        callback()
    }
}
// export const v27101012 = (rule, value, callback) => {
//     if (value < 2.7e-10 || value > 1.0e12) {
//         callback(new Error("输入范围为[2.7E-10，1.0E+12]"))
//     } else {
//         callback()
//     }
// }
// export const v27101012 = (rule, value, callback) => {
//     if (value < 2.7e-10 || value > 1.0e12) {
//         callback(new Error("输入范围为[2.7E-10，1.0E+12]"))
//     } else {
//         callback()
//     }
// }


